function minNumber() {
    var m = arguments[0];

    for (var i = 1; i < arguments.length; i++) {
        if (arguments[i] < m) {
            m = arguments[i]
        }
    }
    return m;
}

function maxNumber() {

}

//用来获取样式
// 参数： ele:dom元素对象 css属性可变

// 返回值  吧获取到的属性值返回

function getStyle(ele,attr)
//在操作对象
//对象.属性  ||对象['属性'|变量]
  {
       
      if(window.getComputedStyle)
      {
        //
        var value=window.getComputedStyle(ele)[attr]
      }else{
        
        var value=ele.currentStyle[attr];
      }
  
            return value;
    
  }

// 作用：实现事件监听的兼容写法
// 参数： ele 事件源 每一次绑定的事件源都不一样
//type 时间类型
// callback 事件处理函数


// 实现某个功能 不需要返回值
function addEvent(ele,type,callback)
{
    if(window.addEventListener)
    {
        ele.addEventListener(type,callback)
    }else{
        ele.attachEvent('on'+type,callback)
    }
}

//给元素增添样式
//用来添加样式
// 参数： ele:dom元素对象 css属性可变

// 返回值  

function setStyle(ele,attr)
//在操作对象
//对象.属性  ||对象['属性'|变量]
  {
       
      if(window.getComputedStyle)
      {
        var value=window.getComputedStyle(ele)[attr]

      }else{
        var value=ele.currentStyle[attr];
      }
  
            return value;
    
  }


  //给元素添加样式
  /*
            作用：给元素添加样式
            参数：
                ele:需要添加样式的元素
                {
                    attr:value
                    attr:添加样式的属性
                    value:添加样式的属性值
                }

        */
                function setStyle(ele, obj) {
                  for (let key in obj) {
                      ele.style[key] = obj[key];
                  }
              }

//  对象转成字符串
function objToStr(obj) {
            // let str = '';
            let arr = [];
            for (let key in obj) {
                // str += key + '=' + obj[key] + '&'

                arr.push(key + '=' + obj[key]);

            }
            console.log(arr);
            
            // 截取除了最后一个数据之外的其他数据
            // let res = str.substr(0, str.length - 1);

            let res = arr.join('&')

            console.log(res);
            return res
        }


        function animation(ele, option, callback) {
          // callback = function(){}
          let moveIndex = 0;
          for (let key in option) {
              moveIndex++;
              let move = function () {
                  let style = parseInt(getStyle(ele, key));
                  let speed = (option[key] - style) / 10;
                  speed = speed > 0 ? Math.ceil(speed) : Math.floor(speed);
                  style += speed;

                  ele.style[key] = style + 'px';
                  if (style == option[key]) {
                      // 当执行这个位置 的时候 说明动画执行已经完成（每一个属性的动画已经完成）
                      // 动画执行结束 需要执行代码可以写在这
                      //每次动画执行结束 之后需要执行代码可能会不一样 不能写死在函数
                      // 把动画执行结束之后的代码当成回调函数进行传递
                      // 当动画执行结束 不需要执行其他的代码的时候 不需要传递回调函数
                      // callback = undefined
                      // && 惰性运算


                      // 当有多个属性参与动画的时候 
                      // 当所有的属性的动画都结束 才表示整个动画已经结束
                      moveIndex--;
                      // if (moveIndex == 0) {
                      //     // 执行这里代码的时候 表示整个动画已经执行结束
                      //     callback && callback();
                      // }

                      // 当花括号中只有依据代码的时候 可以省略花括号不写
                      if (moveIndex == 0) callback && callback();

                      cancelAnimationFrame(ele[key + 'timer']);
                      return
                  }
                  ele[key + 'timer'] = requestAnimationFrame(move)
              }
              cancelAnimationFrame(ele[key + 'timer']);
              ele[key + 'timer'] = requestAnimationFrame(move);
          }
      }


      function ajax(option) {
        let defauldOption = {
            type: 'get',
            async: true,
            data: ''
        }
        // 把默认值 和 传递的值进行合并
        // 如果默认值中的一些属性 有同感参数传递使用 就是传递过来值
        let params = Object.assign(defauldOption, option);
      
        // 对必填的参数做一个判断
        if (!params.url) {
            // 手动抛出错误
            // 执行这句代码之后  不会执行后面代码（return的作用）
            throw Error('url参数是必填')
        }
        if (Object.prototype.toString.call(params.url) != '[object String]') {
            throw Error('url参数的值 必须是string类型')
        }
      
        // 判断success 是必填参数
        if (!params.success) {
            throw Error('success 回调函数是必填参数');
        }
        if (Object.prototype.toString.call(params.success) != '[object Function]') {
            throw Error('success的值必须是一个函数')
        }
      
        // 判断type属性
        if (Object.prototype.toString.call(params.type) != '[object String]') {
            throw Error('type 属性的属性值必须是字符串')
        }
        if (!/(get|post)/gi.test(params.type)) {
            throw Error('type 属性只能为 get 或者 post')
        }
      
        // async 属性的判断 必须为布尔值
        if (Object.prototype.toString.call(params.async) != '[object Boolean]') {
            throw Error('async 属性的值必须为布尔值')
        }
      
        // 判断data 参数的类型
        let dataType = Object.prototype.toString.call(params.data)
        if (dataType != '[object String]' && dataType != '[object Object]') {
            throw Error('data 属性的值必须是string或者Object类型')
        }
        // 如果参数为对象的时候 需要把对象转换为字符串的形式
        // 传递给后端的参数 只能为字符串的形式传递
        if (dataType == '[object Object]') {
            let arr = []
            for (let key in params.data) {
                arr.push(key + '=' + params.data[key])
            }
            params.data = arr.join('&');
        }
      
        // ajax请求的步骤
        let xhr = new XMLHttpRequest();
        // 如果请求方式为get请求
        if (params.type == 'get') {
            // '{"category":"graphic_design"}' 转换为key=value 的形式
            // get  请求 参数直接拼接地址后面 ，参数的格式只能为key=value的形式
            // 所以当参数为json字符串的时候 需要把json数据转换为key=value的格式
            if (params.data.indexOf('{') != -1) {
                let data = JSON.parse(params.data);
                let arr = []
                for (let key in data) {
                    arr.push(key + '=' + data[key])
                }
                params.data = arr.join('&');
            }
            let url = params.data ? params.url + '?' + params.data : params.url;
            xhr.open(params.type, url, params.async);
            xhr.send()
        } else {
            xhr.open(params.type, params.url, params.async);
            // 设置请求头
            //key=value: application/x-www-form-urlencoded
            //'{"key":"value"}' application/json
            let type = params.data.indexOf('=') != -1 ? 'application/x-www-form-urlencoded' : 'application/json';
            xhr.setRequestHeader('Content-Type', type)
            xhr.send(params.data)
        }
      
        // xhr.onreadystatechange  当ajax请求的状态改变的时候 救护执行一次这个事件
        // ajax状态码 xhr.readyState 取值为：0 1 2 3 4 
        // 同步请求执行这里代码 调用回调函数 把结果返回
        if (params.async == false) {
            params.success(JSON.parse(xhr.responseText))
            return
        }
        // 异步请求获取结果的代码
        xhr.onload = function () {
            // success 函数主要用于获取异步请求的结果
            params.success(JSON.parse(xhr.responseText))
        }
      }
      
      
export{ajax}      